C/C++ Users Group Library 1996 July/C-C++ Users Group Library July 1996.iso/vol_300/353_01/chap07.txt

Text File | 1992-01-18 | 22KB | 472 lines

                                                        Chapter 7
                                                      INHERITANCE

One reason to use inheritance is that it allows you to reuse code
from a previous project but gives you the flexibility to slightly
modify it if the old code doesn't do exactly what you need for the
new project.  It doesn't make sense to start every new project from
scratch since some code will certainly be repeated in several
programs and you should strive to build on what you did previously.
Moreover, it is easy to make an error if we try to modify the
original class, but we are less likely to make an error if we leave
the original alone and only add to it.  Another reason for using
inheritance is if the project requires the use of several classes
which are very similar but slightly different.

In this chapter we will concentrate on the mechanism of inheritance
and how to build it into a program.  A better illustration of why
you would use inheritance will be given in later chapters where we
will discuss some practical applications of object oriented
programming.

The principle of inheritance is available with several modern
programming languages and is handled slightly differently with
each.  C++ allows you to inherit all or part of the members and
methods of a class, modify some, and add new ones not available in
the parent class.  You have complete flexibility, and as usual,
the method used with C++ has been selected to result in the most
efficient code execution.


A SIMPLE CLASS TO START WITH
_________________________________________________________________

Examine the file named VEHICLE.H for a simple   =================
class which we will use to begin our study of       VEHICLE.H
inheritance in this chapter.  There is nothing  =================
unusual about this class header, it has been
kept very simple.  It consists of four simple
methods which can be used to manipulate data pertaining to our
vehicle.  What each method does is not especially important at this
time.  We will eventually refer to this as a base class or parent
class, but for the time being, we will simply use it like any other
class to show that it is indeed identical to the classes already
studied.  Note that we will explain the added keyword protected
shortly.

Ignore lines 4, 5, and 17 until the end of this chapter where they
will be explained in detail.  This file cannot be compiled or
executed because it is only a header file.


                                                         Page 7-1

                                          Chapter 7 - Inheritance


THE IMPLEMENTATION FOR VEHICLE
_________________________________________________________________

Examine the file named VEHICLE.CPP and you will   ===============
find that it is the implementation of the           VEHICLE.CPP
vehicle class.  The initialize() method assigns   ===============
the values input as parameters to the wheels and
weight variables.  We have methods to return the
number of wheels and the weight, and finally, we have one that does
a trivial calculation to return the loading on each wheel.  We will
have a few examples of methods that do some significant processing
later, but at this point, we are more interested in learning how
to set up the interface to the classes, so the implementations will
be kept trivial.

As stated above, this is a very simple class which will be used in
the next program.  Later in this tutorial we will use it as a base
class.  You should compile this class at this time in preparation
for the next example program, but you cannot execute it because
there is no entry point.


USING THE VEHICLE CLASS
_________________________________________________________________

The file named TRANSPRT.CPP uses the vehicle     ================
class in exactly the same manner as we             TRANSPRT.CPP
illustrated in the last chapter.  This should be ================
an indication to you that the vehicle class is
truly nothing more than a normal class as
defined in C++.  We will make it a little special, however, by
using it unmodified as a base class in the next few example files
to illustrate inheritance.  Inheritance uses an existing class and
adds functionality to it to accomplish another, possibly more
complex job.

You should have no problem understanding the operation of this
program.  It declares four objects of the vehicle class,
initializes them, and prints out a few of the data points to
illustrate that the vehicle class can be used as a simple class
because it is a simple class.  We are referring to it as a simple
class as opposed to calling it a base class or derived class as we
will do shortly.

If you thoroughly understand this program, you should compile and
execute it, remembering to link the vehicle object file with this
object file.

OUR FIRST DERIVED CLASS
_________________________________________________________________

Examine the file named CAR.H for our first example of the use of
a derived class or child class.  The vehicle class is inherited due

                                                         Page 7-2

                                          Chapter 7 - Inheritance

to the ": public vehicle" added to line 4.  This   ==============
derived class named car is composed of all of           CAR.H
the information included in the base class         ==============
vehicle, and all of its own additional
information.  Even though we did nothing to the
class named vehicle, we made it into a base class because of the
way we are using it here.  To go a step further, even though it
will be used as a base class in an example program later in this
chapter, there is no reason it cannot continue to be used as a
simple class in the previous example program.  In fact, it can be
used as a single class and a base class in the same program.  The
question of whether it is a simple class or a base class is
answered by the way it is used.

A discussion of terminology is needed here.  When discussing object
oriented programming in general, a class that inherits another is
often called a derived class or a child class, but the most proper
term as defined for C++ is a derived class.  Since these terms are
very descriptive, and most writers tend to use the terms
interchangeably, we will also use these terms in this tutorial.
Likewise the proper C++ terminology for the inherited class is to
call it a base class, but parent class and super class are
sometimes used.

A base class is a rather general class which can cover a wide range
of objects, whereas a derived class is somewhat more restricted but
at the same time more useful.  For example if we had a base class
named programming language and a derived class named C++, then we
could use the base class to define Pascal, Ada, C++, or any other
programming language, but it would not tell us about the use of
classes in C++ because it can only give a general view of each
language.  On the other hand, the derived class named C++ could
define the use of classes, but it could not be used to describe the
other languages because it is too narrow.  A base class tends to
be more general, and a derived class is more specific.

In this case, the vehicle base class can be used to declare objects
that represent trucks, cars, bicycles, or any number of other
vehicles you can think up.  The class named car however can only
be used to declare an object that is of type car because we have
limited the kinds of data that can be intelligently used with it.
The car class is therefore more restrictive and specific than the
vehicle class.  The vehicle class is more general than the car
class.

If we wished to get even more specific, we could define a derived
class using car as the base class and name it sports_car and
include such information as red_line_limit for the tachometer which
would be silly for the family station wagon.  The car class would
therefore be used as a derived class and a base class at the same
time, so